import sun.awt.windows.ThemeReader;

public class ThreadDemo {
    public static void main(String[] args) {

        MyThread myThread = new MyThread();
        //启动线程
        myThread.start();

        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();

        MyRunnable3 myRunnable3 = new MyRunnable3();
        Thread thread3 = new Thread(myRunnable3);
        //设置为守护线程，当用户线程没有了，JAVA虚拟机就退出了该守护线程不会执行了
        thread3.setDaemon(true);
        thread3.start();

        for (int i = 0; i < 50; i++) {
            System.out.println("main-"+i);
        }
    }

}

//实现线程一：继承Thread
class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-" + i);

            try {
                //休眠
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//实现线程二[推荐]：实现Runnable接口，此时是一个任务，看他放在哪个线程中
//推荐理由：（1）接口可以实现多个；（2）可以放到不同的Thread中。
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-" + i);
        }
    }
}

//线程的休眠：在当前线程的执行中，以指定的毫秒数(纳秒)暂停，释放CPU的时间片，让其他的线程可以执行
//如果任何线程中断当前线程，抛出InterruptedException时，当前线程的中断状态将被清除。
//不释放监视器的所有权（对象锁），即如果上锁了，依然被锁住。
//public static void sleep(long millis)
//public static void sleep(long millis, int nanos)

//等待这个线程执行指定时间或者执行完，使并行变串行，作用是同步
//public final void join() throws InterruptedException

//中断线程：只是做了一个中断标记，并不会中断。
//public void interrupt()
//Thread.currentThread().interrupt();
//测试中断状态，此方法会把中断状态清除
//public static boolean interrupted()
//if(Thread.interrupted()){break;}

//自定义中断标记
class MyRunable2 implements Runnable {
    public boolean flag = true;

    public MyRunable2() {
        flag = true;
    }

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println(Thread.currentThread().getName() + "-" + (i++));
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//(new MyRunable2()).flag = false;

//线程分为守护线程和用户线程
//将此线程标记为用户线程。当运行的唯一线程是守护进程线程时，JAVA虚拟机将退出。
//true为守护线程，false为用户线程
//public final void setDaemon(boolean on)
//作用：当某一线程不运行了时，其他线程也不用运行了
class MyRunnable3 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("--"+i);

        }
    }
}

//测试是否为守护线程
//public final boolean isDaemon()

//暂停当前正在执行的线程，让出本次CPU执行的时间片
//public static void yield()

//返回线程的标识符
//long getId()

//返回线程的名称
//String getName()

//改变线程名称，使之与参数name相同
//void setName(String name)

//测试线程是否处于活动状态
//star()之前是false,之后是true
//boolean isAlive()

//更改优先级，优先级高可以提高该线程抢占CPU时间片的概率
//void setPriority(int newPriority)
//最高、最低、默认
//static int MAX_PRIORITY,static int MIN_PRIORITY,static int NORM_PRIORITY

//yield()作用是让步，它能够让当前线程从“运行状态”进入到“就绪状态”，从而让其他等待线程获取执行权，但是不能保证在当前线程调用yield()之后，其他线程就一定能获得执行权，也有可能是当前线程又回到“运行状态”继续运行。

